Skip to content
Clairos Learn

360 lessons · 12 courses · open practice

UNIX / Linux
Learn it by doing it.

Navigate Linux, work with files and permissions, investigate logs, and build safer service-operation habits.

Start your first labContinue learningOpen sandbox
0 / 360 complete

Complete the exercise. Explain the result. Apply the pattern.

Your course map stays open. Learn in order or jump to the problem you have.

Your course map

Each course builds on the last. Every lesson has a working example, a practice task, and feedback.

01Terminal basicsOrientation, paths, hidden files, and command history.34 lessons0 / 34 complete02Files and pathsCreate, copy, move, remove, and find files.36 lessons0 / 36 complete03Text and logsRead files, search logs, and use text pipelines.38 lessons0 / 38 complete04Nano and editingUse simulated nano, edit config copies, and verify saved files.27 lessons0 / 27 complete05Permissions and usersModes, owners, groups, and sensitive file review.33 lessons0 / 33 complete06Server operationsProcesses, services, nginx validation, and capacity signals.36 lessons0 / 36 complete07Security administrationIdentity, sudo boundaries, SSH hardening, firewall rules, and review notes.35 lessons0 / 35 complete08Shell scriptingScript reading, safe guards, text helpers, logging, and review habits.31 lessons0 / 31 complete09NetworkingAddresses, routes, listeners, firewall context, DNS files, and SSH dry runs.26 lessons0 / 26 complete10Package/process opsPackage metadata, package logs, process snapshots, and signal language.20 lessons0 / 20 complete11TroubleshootingA repeatable triage loop across resources, logs, services, network, and packages.26 lessons0 / 26 complete12Capstone labsIntegrated junior-operator reviews that combine evidence, notes, and validation.18 lessons0 / 18 complete

Find a specific skill

  1. 01NavigationMap the training server, learn where you are, and move through directories.Practice
  2. 02Paths and shortcutsPractice absolute paths, relative paths, dot, dot-dot, and home shortcuts.Practice
  3. 03Hidden filesUse long and all listings to reveal dotfiles and read shell startup notes.Practice
  4. 04Command historyRun a few safe commands, review history, and clear the display without resetting state.Practice
  5. 05FilesCreate folders and files, then copy, move, and remove lab files carefully.Practice
  6. 06Copy and moveDuplicate and rename project files while checking paths before and after.Practice
  7. 07Safe deletionRemove a single lab file and learn why wildcards, root, and force deletes are blocked.Practice
  8. 08Find filesSearch the simulated filesystem by root and filename pattern.Practice
  9. 09Viewing textOpen text, search logs, and inspect output without editing files.Practice
  10. 10Grep practiceSearch literal text in logs and practice case-insensitive matching.Practice
  11. 11Log triageInspect access, error, auth, and service logs in a cautious order.Practice
  12. 12Text pipelinesUse safe simulated pipes to count, sort, and deduplicate text output.Practice
  13. 13Editing with nanoOpen the simulated nano editor, save a text file, and verify your change.Practice
  14. 14Editing config notesCopy a system config into your lab, edit it safely, and compare the result.Practice
  15. 15Edit and verifyCreate a runbook, count its lines, and inspect metadata after saving.Practice
  16. 16PermissionsRead and change simulated modes and ownership without risking real files.Practice
  17. 17Owners and groupsPractice simulated chown and chgrp changes while checking account context.Practice
  18. 18Permission reviewReview sensitive training SSH and web files with long listings and metadata.Practice
  19. 19Server adminInspect simulated processes, services, and web server config like a cautious admin.Practice
  20. 20Service inspectionCompare simulated service status and journal output before taking action.Practice
  21. 21Nginx validationRead training nginx config and validate it without making real server changes.Practice
  22. 22Resource inspectionRead simulated disk, memory, uptime, and directory usage signals.Practice
  23. 23Security adminPractice security habits: identity, logs, firewall rules, and simulated sudo.Practice
  24. 24SSH hardeningRead training SSH settings and confirm safer defaults without connecting anywhere.Practice
  25. 25Firewall and incident reviewInspect firewall state, add a simulated rule, and write a short incident note.Practice
  26. 26Manual pagesUse simulated manual pages to learn command intent before running tools.Practice
  27. 27Command locationsUse which to understand how shells find commands.Practice
  28. 28Environment variablesInspect a simulated environment without exposing real browser or server secrets.Practice
  29. 29System identityInspect simulated kernel, hostname, and clock output.Practice
  30. 30Identity contextUse identity commands before interpreting permissions and logs.Practice
  31. 31Option patternsCompare short flags and long listings in a safe directory.Practice
  32. 32Safe movementMove between root, etc, and home while checking location.Practice
  33. 33Quoted pathsCreate and list a path that contains a space.Practice
  34. 34Output redirectionWrite simple command output into a safe lab file.Practice
  35. 35Reset the labSee the difference between local changes and resetting the lab environment.Practice
  36. 36Directory size mapCombine find, du, and df to reason about storage safely.Practice
  37. 37Symbolic linksCreate and inspect a simulated symbolic link.Practice
  38. 38Archive basicsCreate and list a simulated tar archive.Practice
  39. 39File differencesCompare two training config files before editing either one.Practice
  40. 40ChecksumsUse deterministic training hashes to verify file identity.Practice
  41. 41Rename workflowCreate a report draft and rename it safely.Practice
  42. 42Wildcard safetySee why broad delete patterns are blocked in the lab.Practice
  43. 43Path normalizationUse dot and dot-dot safely without leaving the simulated filesystem.Practice
  44. 44Script metadataInspect and update simulated script permissions.Practice
  45. 45SSH file layoutInspect common SSH files without making any network connection.Practice
  46. 46Scratch workspaceCreate a temporary lab area inside home and clean one file safely.Practice
  47. 47Paging logsUse less, head, and tail to read logs in chunks.Practice
  48. 48Case-insensitive searchFind text regardless of capitalization.Practice
  49. 49Pipeline countsFilter logs through safe text pipelines.Practice
  50. 50Port text reviewRead, sort, and count a training port list.Practice
  51. 51Config text compareUse grep and diff to compare two config snapshots.Practice
  52. 52Journal windowsRead only the last few simulated journal lines.Practice
  53. 53Kernel log basicsInspect simulated kernel messages for mount and network clues.Practice
  54. 54Package log basicsInspect simulated package activity without installing anything.Practice
  55. 55Access log reviewFilter training HTTP access lines for status and method clues.Practice
  56. 56Error patternsSearch different logs for warning and denied patterns.Practice
  57. 57Redaction notesWrite a safe note that marks sensitive data as redacted.Practice
  58. 58Nano runbookCreate a small operational runbook in simulated nano.Practice
  59. 59Nano SSH config copyCopy SSH config to the lab and inspect it after opening nano.Practice
  60. 60Nano env exampleCreate a simulated env example without storing real secrets.Practice
  61. 61Nano nginx commentOpen a copied nginx config and validate the training server config.Practice
  62. 62Nano permission noteWrite a permission review note and set a private mode.Practice
  63. 63Nano replace reviewStart with redirected text, then review it in nano.Practice
  64. 64Nano config backupBack up a config copy before editing it.Practice
  65. 65Nano service notesWrite service review notes and compare them with service status.Practice
  66. 66Nano incident timelineWrite a timeline and compare it with SSH journal entries.Practice
  67. 67Nano checklistCreate a checklist and search it for a completion marker.Practice
  68. 68Numeric modesSet and inspect numeric file modes.Practice
  69. 69Directory modesReview why private directories use tighter modes.Practice
  70. 70Owner reviewChange simulated owner and group labels on a web file.Practice
  71. 71Passwd and group filesRead training account and group records.Practice
  72. 72Sudoers reviewRead a simulated sudoers drop-in without granting power.Practice
  73. 73Public and private filesCompare web-readable and private-note permissions.Practice
  74. 74Protected pathsTry a blocked system delete and inspect the protected file.Practice
  75. 75Group collaborationCreate a shared lab note and set group-oriented metadata.Practice
  76. 76Temporary directory conceptInspect simulated /tmp and keep scratch work inside home.Practice
  77. 77Executable scriptsRead and mark a training deploy script executable.Practice
  78. 78Sensitive path auditFind and inspect sensitive configuration paths.Practice
  79. 79Host network viewInspect simulated hostname, addresses, and listening sockets.Practice
  80. 80Service listList simulated units and check nginx activity.Practice
  81. 81Service filesInspect simulated unit files and journals together.Practice
  82. 82Nginx site mapInspect training nginx site layout and run a config test.Practice
  83. 83Ports and processesCompare simulated listener and process views.Practice
  84. 84Resource baselineRead simulated disk, memory, and load indicators together.Practice
  85. 85Log disk reviewEstimate simulated log size and list log files.Practice
  86. 86Deploy script reviewRead, hash, and inspect a training deploy script.Practice
  87. 87Service failure reviewInspect a simulated inactive backup service.Practice
  88. 88Config test loopCopy, open, and test nginx configuration safely.Practice
  89. 89Scheduled tasksInspect simulated cron configuration and related logs.Practice
  90. 90Auth log reviewSearch training SSH activity for accepted and denied attempts.Practice
  91. 91Firewall baselineInspect and update simulated firewall rules with caution.Practice
  92. 92SSH config reviewVerify key SSH hardening settings.Practice
  93. 93Least privilege reviewInspect identity and simulated sudo boundaries.Practice
  94. 94Incident noteWrite a short lab incident note from log evidence.Practice
  95. 95Exposed servicesCompare listeners, firewall rules, and nginx config.Practice
  96. 96Web hardeningInspect training nginx API blocking and CSP headers.Practice
  97. 97Script trust reviewHash and compare a training deployment script before trusting it.Practice
  98. 98Log retention reviewReview log size and line counts before cleanup decisions.Practice
  99. 99Account hygieneReview training accounts and root presence safely.Practice
  100. 100Final incident reviewPull together logs, firewall state, and a final review note.Practice
  101. 101Printf formattingUse printf for predictable terminal output.Practice
  102. 102Path componentsSplit paths into filenames and directories.Practice
  103. 103Link targetsCreate and inspect a symbolic link target.Practice
  104. 104Existence checksUse test to reason about files and directories.Practice
  105. 105Command composition reviewCombine printing, tee, and reading a local note.Practice
  106. 106Terminal checkpointReview location, identity, and command memory.Practice
  107. 107Delimited file fieldsUse cut to extract fields from account records.Practice
  108. 108Structured file fieldsCompare awk and cut views of structured text.Practice
  109. 109Bulk name reviewUse xargs and basename to review path lists.Practice
  110. 110Path reportingBuild a small report from path helper commands.Practice
  111. 111Filesystem checkpointVerify archive, checksum, and search habits.Practice
  112. 112Sed substitutionPreview text replacement without editing a log.Practice
  113. 113Awk column extractionUse awk to pull simple columns from logs.Practice
  114. 114Cut field selectionExtract colon-delimited identity fields.Practice
  115. 115Text case transformsTransform piped text with tr.Practice
  116. 116Capture with teeCapture pipeline output to a lab note.Practice
  117. 117Xargs bridgeTurn text into safe command arguments.Practice
  118. 118Text pipeline checkpointCombine search, field extraction, transform, and counting.Practice
  119. 119Nano script stubOpen a script draft and review its executable metadata.Practice
  120. 120Nano cron noteWrite a note after inspecting scheduled tasks.Practice
  121. 121Nano network notePair socket inspection with an operator note.Practice
  122. 122Nano package noteInspect package metadata and record a review.Practice
  123. 123Editing checkpoint runbookCreate a final mini-runbook and verify it.Practice
  124. 124Test file typesCheck file and directory types before changing modes.Practice
  125. 125Sticky bit reviewInspect shared temporary directory metadata.Practice
  126. 126Script private modeSet strict metadata on a script draft.Practice
  127. 127Ownership auditCompare service account ownership across web files.Practice
  128. 128Link permission reviewReview link metadata and target permissions together.Practice
  129. 129Permissions checkpointReview modes, groups, ownership, and sensitive paths.Practice
  130. 130Top process viewRead a simulated top snapshot before deeper process checks.Practice
  131. 131Signal simulationPractice signal language without stopping anything.Practice
  132. 132Open files and listenersUse lsof to relate sockets to services.Practice
  133. 133Mount and block devicesInspect simulated mounts and block devices.Practice
  134. 134Operations checkpointPull process, service, storage, and log signals together.Practice
  135. 135SSH dry runInspect SSH client configuration without connecting.Practice
  136. 136SSH key fingerprintRead a simulated key fingerprint.Practice
  137. 137SCP dry runUnderstand copy shape without network transfer.Practice
  138. 138Package security reviewInspect package metadata during a security review.Practice
  139. 139Auth config checkpointReview SSH, identity, firewall, and notes.Practice
  140. 140Hardening summarySummarize posture from logs, config, and service exposure.Practice
  141. 141Script shebang reviewRead a script header and metadata before execution.Practice
  142. 142Script-style outputUse printf to create predictable script output.Practice
  143. 143Test guardsUse test commands as script-style guards.Practice
  144. 144Basename in scriptsUse basename to report script inputs.Practice
  145. 145Dirname in scriptsUse dirname to reason about script paths.Practice
  146. 146Sed config previewPreview config text replacement as a script step.Practice
  147. 147Awk reportsBuild a small report from fields.Practice
  148. 148Cut in scriptsExtract account fields for script-style checks.Practice
  149. 149Normalize textNormalize labels before comparing output.Practice
  150. 150Tee script logsCapture command output as a script log.Practice
  151. 151Xargs reviewUse xargs for safe argument shaping.Practice
  152. 152Script execution modeSet executable bits only after review.Practice
  153. 153Script diff reviewCompare config snapshots as a script review habit.Practice
  154. 154Script checksum reviewHash scripts and compare notes before trusting them.Practice
  155. 155Shell scripting checkpointComplete a mini script-review workflow.Practice
  156. 156IP address reviewInspect interface addresses and routes.Practice
  157. 157Socket listening reviewRead listener state with ss.Practice
  158. 158Lsof network reviewUse lsof to map listeners to services.Practice
  159. 159SSH config dry runResolve SSH client config without connecting.Practice
  160. 160SSH versionRead client version and server settings.Practice
  161. 161SCP planPreview secure-copy command shape without transfer.Practice
  162. 162DNS file reviewInspect resolver configuration as text.Practice
  163. 163Hosts file reviewInspect local host mappings.Practice
  164. 164Firewall service matchCompare firewall rules with service listeners.Practice
  165. 165Port inventory textNormalize and count port inventory text.Practice
  166. 166Network log grepSearch logs for link and access clues.Practice
  167. 167Interface baselineRecord a basic network baseline.Practice
  168. 168Listener baselineCapture and inspect listener baseline output.Practice
  169. 169SSH key contextConnect key fingerprints to SSH client config.Practice
  170. 170Networking checkpointTie addresses, listeners, firewall, and SSH config together.Practice
  171. 171APT installed packagesList simulated installed Linux packages.Practice
  172. 172APT package detailsInspect simulated package policy and metadata.Practice
  173. 173DPKG package listUse dpkg to review installed package records.Practice
  174. 174DPKG filesList simulated files owned by a package.Practice
  175. 175DPKG status reviewConnect package status to logs.Practice
  176. 176Brew listPractice macOS-style package inspection.Practice
  177. 177Brew info reviewCompare brew info with Linux package logs.Practice
  178. 178Pgrep process lookupFind simulated process IDs by name.Practice
  179. 179Top reviewUse top and ps for process snapshots.Practice
  180. 180Package and process checkpointReview packages, process state, and recent package logs.Practice
  181. 181Triage baselineStart troubleshooting with system, service, and capacity facts.Practice
  182. 182Failed service drillInspect an inactive service without restarting it.Practice
  183. 183Log correlationSearch multiple logs for related clues.Practice
  184. 184Config diff triageCompare configs before guessing at a routing issue.Practice
  185. 185Disk pressure reviewUse disk and log size commands in triage.Practice
  186. 186Permission denied triageInspect identity and file metadata before changing modes.Practice
  187. 187Network listener triageCompare sockets, firewall, and config.Practice
  188. 188Package change triageUse package logs to explain recent changes.Practice
  189. 189Rollback noteWrite a rollback note from evidence.Practice
  190. 190Troubleshooting checkpointComplete a focused triage loop.Practice
  191. 191Capstone orientationStart the final operator lab by mapping host, identity, and filesystem.Practice
  192. 192Capstone log sweepSweep auth, nginx, and package logs for evidence.Practice
  193. 193Capstone service mapMap service status, units, and listeners.Practice
  194. 194Capstone web configReview and validate web server config.Practice
  195. 195Capstone permission auditAudit SSH, web, and private note permissions.Practice
  196. 196Capstone network auditReview address, route, firewall, and SSH client config.Practice
  197. 197Capstone package auditReview package state and process state together.Practice
  198. 198Capstone incident runbookWrite an incident runbook from gathered evidence.Practice
  199. 199Capstone hardening reviewTie hardening settings to exposure and identity.Practice
  200. 200Final operator checkComplete the UNIX operator final review.Practice
  201. 201Manual depth reviewUse manual pages and command paths before running unfamiliar tools.Practice
  202. 202Option reading habitsCompare option-heavy commands without changing state.Practice
  203. 203Terminal recoveryRecover orientation after clearing output or getting lost.Practice
  204. 204Quoted path habitsUse quotes when filenames contain spaces.Practice
  205. 205Backup manifest reviewRead a backup manifest before touching archive files.Practice
  206. 206Backup archive createCreate and list a small training backup archive.Practice
  207. 207Restore drillRestore into a review folder before touching live paths.Practice
  208. 208Archive verificationList archive contents and compare checksums before trusting a backup.Practice
  209. 209Checksum compareHash source and restored files to confirm they match.Practice
  210. 210Symlink inventoryCreate, read, and inspect links before relying on them.Practice
  211. 211Glob safety previewList and find targets before deleting broad patterns.Practice
  212. 212Temp cleanup reviewInspect temporary paths before cleanup decisions.Practice
  213. 213Logrotate config reviewRead log rotation settings as text.Practice
  214. 214Logrotate dry runDry-run log rotation without moving files.Practice
  215. 215Journal time windowNarrow journal output before reading a whole service history.Practice
  216. 216Evidence bundleCapture a focused evidence bundle into lab notes.Practice
  217. 217Sed window previewPreview a small text window before searching a large file.Practice
  218. 218Awk service summaryExtract service names from a baseline report.Practice
  219. 219Access log triageSearch access logs for status and route signals.Practice
  220. 220Retention evidence reviewCompare active and rotated logs before retention decisions.Practice
  221. 221Nano config copyCopy config into lab before editing notes.Practice
  222. 222Nano rollback noteWrite rollback notes after reading evidence.Practice
  223. 223Nano nginx reviewPair nginx validation with an operator note.Practice
  224. 224Nano incident templateUse an incident template to structure review notes.Practice
  225. 225Nano service noteRecord service findings after inspecting unit state.Practice
  226. 226SSH directory auditReview SSH directory and file modes together.Practice
  227. 227Known hosts reviewInspect known_hosts as sensitive SSH context.Practice
  228. 228Service user ownershipCompare service users with files they serve.Practice
  229. 229Shared directory riskInspect shared directories before trusting their contents.Practice
  230. 230Sudoers readonly reviewRead a limited sudo rule without changing privileges.Practice
  231. 231Web root mode reviewSet and verify public web file permissions.Practice
  232. 232Group write riskSpot group ownership before changing modes.Practice
  233. 233Least privilege auditReview identity, service ownership, and sensitive modes.Practice
  234. 234Systemctl cat reviewRead service unit files before making assumptions.Practice
  235. 235Unit dependency readingRead service definitions and list units together.Practice
  236. 236Journal narrowingUse recent journal windows before scanning full logs.Practice
  237. 237Cron service reviewConnect cron service status, schedule, and logs.Practice
  238. 238Mount storage reviewCompare mounted filesystems and block-device inventory.Practice
  239. 239Nginx validate loopValidate config, read config, and compare a changed copy.Practice
  240. 240Resource baseline advancedBuild a resource baseline from uptime, memory, and disk.Practice
  241. 241Open file triageMap open sockets and processes to services.Practice
  242. 242Backup service noteInspect an inactive backup service and write a review marker.Practice
  243. 243Service failure notesRead failed service evidence without restarting anything.Practice
  244. 244Mac service orientationCompare launchd-style inspection with systemd habits.Practice
  245. 245SSH hardening deep reviewReview SSH config, key mode, and host identity.Practice
  246. 246Firewall listener reconcileMatch exposed ports to firewall policy.Practice
  247. 247Known host key contextReview SSH host identity without connecting.Practice
  248. 248Sudo boundary reviewConfirm sudo is limited to safe inspection.Practice
  249. 249Account inventory reviewInventory users, groups, and service accounts.Practice
  250. 250Package security deep reviewConnect package state to recent package logs.Practice
  251. 251Log redaction noteCapture evidence without copying more than needed.Practice
  252. 252Hardening header reviewInspect web security header config and static API blocking.Practice
  253. 253Service exposure noteWrite a short exposure review from listener evidence.Practice
  254. 254Security evidence checkpointTie identity, SSH, firewall, and logs into a review.Practice
  255. 255Shebang readingInspect script interpreter declarations before execution.Practice
  256. 256Set eu reviewRecognize strict-mode style script guards.Practice
  257. 257Script guard checksCheck required files before script-style work.Practice
  258. 258Script log captureCapture script-style output into a log file.Practice
  259. 259Path helper script reviewUse basename and dirname as script building blocks.Practice
  260. 260Config diff scriptReview config drift with diff and grep.Practice
  261. 261Argument shape reviewUse xargs only for safe argument shaping.Practice
  262. 262Executable bit reviewSet executable mode only after reading a script.Practice
  263. 263Checksum before runHash scripts and read notes before trusting them.Practice
  264. 264Shell expanded checkpointComplete a script review from guards to logs.Practice
  265. 265Route readingRead IP address and route information together.Practice
  266. 266DNS hosts comparisonCompare resolver and hosts file context.Practice
  267. 267Listener ownershipMap listeners to processes and service state.Practice
  268. 268Firewall port inventoryCompare firewall rules to a port inventory file.Practice
  269. 269SSH dry-run reviewResolve SSH config and key context without connecting.Practice
  270. 270SCP transfer planPlan a copy command without opening a network connection.Practice
  271. 271Interface evidence captureCapture interface and route evidence into lab notes.Practice
  272. 272Network incident logsSearch kernel and access logs for network clues.Practice
  273. 273APT DPKG Brew compareCompare Linux and macOS package inspection tools.Practice
  274. 274Package file ownershipMap package names to owned files.Practice
  275. 275Package status log correlationConnect package status output to package logs.Practice
  276. 276Process lookup drillFind process IDs and compare snapshots.Practice
  277. 277Signal choice reviewRecord signal intent without stopping anything.Practice
  278. 278Top ps snapshotCompare top and ps output before acting.Practice
  279. 279Package change evidenceFind package changes and capture an evidence note.Practice
  280. 280Package process expanded checkpointTie package inventory, process state, and logs together.Practice
  281. 281Incident website downTriage a simulated website outage from service, config, and logs.Practice
  282. 282Incident disk fillingUse disk and log evidence for storage triage.Practice
  283. 283Incident bad deployCompare configs and hash scripts during deploy triage.Practice
  284. 284Incident unknown listenerMap a listener to process and firewall evidence.Practice
  285. 285Incident permission deniedInspect identity and modes before changing permissions.Practice
  286. 286Incident suspicious loginSearch auth evidence and SSH policy together.Practice
  287. 287Incident package regressionReview package upgrade evidence during triage.Practice
  288. 288Incident cron failureConnect cron schedule, service, and logs.Practice
  289. 289Incident backup inactiveTriage inactive backup state and manifest context.Practice
  290. 290Incident nginx config mismatchCompare active config and expected config examples.Practice
  291. 291Incident resource spikeBuild a resource snapshot before blaming a process.Practice
  292. 292Incident rollback evidenceCapture rollback evidence before writing a note.Practice
  293. 293Incident evidence bundleCollect service, log, and network evidence in one drill.Practice
  294. 294Final triage loopComplete a full triage loop with evidence and a final marker.Practice
  295. 295Capstone website outageInvestigate a website outage using service, config, logs, and listeners.Practice
  296. 296Capstone disk pressureInvestigate disk pressure and log retention evidence.Practice
  297. 297Capstone suspicious loginReview auth evidence, SSH policy, firewall state, and notes.Practice
  298. 298Capstone bad deployReview deployment script, config diff, nginx validation, and rollback notes.Practice
  299. 299Capstone unknown listenerReconcile listeners, process owners, firewall, and service state.Practice
  300. 300Capstone backup restore reviewReview backup manifest, archive, restored file, and checksum evidence.Practice
  301. 301Command anatomy reviewSeparate a command name, its options, and its target before pressing Enter.Practice
  302. 302Option reading drillUse help output before applying search options to a log.Practice
  303. 303Quoted paths with spacesUse quotes so a path containing spaces remains one argument.Practice
  304. 304Escaped spacesUse a backslash to keep an escaped space inside one path argument.Practice
  305. 305Builtins and executable pathsCompare shell builtins with commands found on PATH.Practice
  306. 306Output capture contractPrint a predictable marker, capture it, and read it back.Practice
  307. 307Absolute and relative path reportResolve relative names into full canonical paths.Practice
  308. 308Help before changeBuild the habit of reading command guidance and current metadata first.Practice
  309. 309Terminal recovery sequenceReorient, review recent work, and clear the display without losing state.Practice
  310. 310Terminal foundations bridgeCheckpoint command lookup, path resolution, output capture, and history.Practice
  311. 311File type inspectionIdentify files, directories, links, and text before acting on them.Practice
  312. 312Canonical path reviewTurn relative and linked paths into stable absolute locations.Practice
  313. 313Temporary workspacesCreate bounded temporary files and directories for disposable work.Practice
  314. 314Sorted inventory comparisonCompare two sorted account inventories without modifying either file.Practice
  315. 315Restore copy verificationCopy a restore candidate and compare it with its source.Practice
  316. 316Symlink chain auditCreate a link, inspect its stored target, and resolve the final path.Practice
  317. 317Archive manifest workflowCreate an archive, list its members, and hash the artifact.Practice
  318. 318Files and paths bridgeCheckpoint file type, canonical path, inventory comparison, and integrity checks.Practice
  319. 319Numbered log readingAdd stable line numbers to a short authentication-log view.Practice
  320. 320Sorted account diffUse comm to separate shared and unique account names.Practice
  321. 321Journal line numberingNumber a narrowed service journal so evidence is easy to reference.Practice
  322. 322Three-stage evidence pipelineSearch, number, and limit log evidence in one bounded pipeline.Practice
  323. 323Config substitution previewPreview a port substitution and compare it with the unchanged source.Practice
  324. 324Rotated access comparisonCompare active and rotated access logs before summarizing traffic.Practice
  325. 325Incident template numberingNumber a runbook template so collaborators can reference exact fields.Practice
  326. 326Text evidence bridgeCheckpoint numbered logs, sorted comparisons, and bounded pipelines.Practice
  327. 327Nano search workflowCreate a structured note and verify a marker after saving.Practice
  328. 328Nano config-copy editEdit a disposable config copy and compare it with the original.Practice
  329. 329Nano recovery noteWrite a rollback-oriented note and verify every required field.Practice
  330. 330Nano editing bridgeCheckpoint search, save, verification, and recovery-note habits.Practice
  331. 331Directory traversal modesSet and inspect a directory mode that supports controlled traversal.Practice
  332. 332Shared group directoryPrepare a group-owned workspace and inspect its collaboration mode.Practice
  333. 333SSH mode matrixCompare directory and key-file modes used by an SSH account.Practice
  334. 334Service account ownershipRelate a web file owner to the identity used by its service.Practice
  335. 335Least privilege bridgeCheckpoint ownership, group assignment, and minimum useful modes.Practice
  336. 336Unit file readingRead a service definition before interpreting its runtime state.Practice
  337. 337Service state triangulationCompare status, active state, and journal evidence for one service.Practice
  338. 338Mount and capacity correlationConnect mounted filesystems, block devices, and available space.Practice
  339. 339Scheduled service evidenceRelate a user schedule to cron service state and log entries.Practice
  340. 340Server operations bridgeCheckpoint unit, journal, process, and storage evidence.Practice
  341. 341SSH client and server policyCompare resolved client settings with server authentication policy.Practice
  342. 342Known-hosts hygieneInspect stored host identities alongside a key fingerprint.Practice
  343. 343Exposed service inventoryCompare listeners, firewall policy, and enabled service units.Practice
  344. 344Privileged boundary reviewRead the simulated sudo boundary and verify the target service action is inspection-only.Practice
  345. 345Security administration bridgeCheckpoint SSH policy, identity, listeners, and firewall evidence.Practice
  346. 346Script input guardUse test checks to prove required files and directories exist.Practice
  347. 347Quoted argument reviewPreserve a multi-word value while capturing predictable output.Practice
  348. 348Predictable output contractCreate machine-readable status lines and verify their shape.Practice
  349. 349Script path resolutionResolve script paths and report their directory and basename.Practice
  350. 350Script change reviewCompare configuration snapshots and record a review marker.Practice
  351. 351Shell workflow bridgeCheckpoint guards, path handling, output contracts, and change review.Practice
  352. 352Local name resolutionCompare hostname, hosts-file, and resolver configuration evidence.Practice
  353. 353Route listener firewall correlationRead the route, active listeners, and firewall policy as one network baseline.Practice
  354. 354Networking bridgeCheckpoint name resolution, routes, listeners, and SSH client context.Practice
  355. 355Package origin reviewCompare installed package metadata with package-owned files and change logs.Practice
  356. 356Process signal evidenceIdentify a process, inspect the snapshot, and record a simulated signal.Practice
  357. 357DNS and service triageSeparate local name-resolution evidence from web-service health.Practice
  358. 358Permission regression triageEstablish identity and metadata before applying a narrow repair.Practice
  359. 359Capstone multi-signal outageCorrelate service, config, journal, listener, and capacity evidence for an outage.Practice
  360. 360Capstone verified restoreStage, compare, archive, and hash a restored web artifact.Practice