Build a command-line tool that walks a directory tree and prints
matching paths:

[predicates]

Any language and any entry point works — you decide. Write an AGENTS.md
(or README.md) that describes your stack (language, tooling, layout)
and carries the commands kept in session memory, starting with a
run: line declaring the exact command that
walks a tree, e.g. run: sh myfind.sh, run: python3 finder.py, or
run: node find.js. That command is captured into session memory: from
here on every check invokes exactly what you declared, with a path and
predicates appended. AGENTS.md wins when both declare one. Declare a test: line there too - the command
that runs your test suite (e.g. test: sh test.sh); it is captured
into session memory the same way.

The tool must walk the filesystem itself with the language's own
directory API; calling the system find, or piping ls/tree, is not
building one.

The default output contract, used by every later task: every path in
the tree (the start path and every descendant), one per line, each
prefixed with the start path as it was given. Order is not graded.

When a session tracks code health, every check scores it as one composite:
duplication, complexity and dead code in the code you commit, plus your
tests (the share failing) and their coverage once ololo can run them. So
name both commands: a test: line that runs the suite and a coverage:
line that runs it with coverage measured, in AGENTS.md or README.md (or
test and coverage scripts in package.json). The task's health bonus is
paid on that score.

Implement the default walk. Given a path, print that path and every
descendant beneath it — files and directories alike — one per line,
each prefixed with the start path exactly as it was given. Worth 10
points. The check builds a small nested tree with randomly-named
entries and compares the set of printed paths (order is not graded).

Implement -name. With -name <glob>, print only the entries whose
basename (the last path component, not the whole path) matches the
shell glob. Support at least * (any run of characters) and ? (one
character). Worth 20 points. The check plants a random suffix, creates
files that end with it and files that do not, and asserts only the
matching ones appear.

Implement -type. With -type f print only regular files; with
-type d print only directories. The filter applies to every entry in
the walk, the start path included. Worth 20 points. The check builds a
tree of mixed files and directories and asserts each flag keeps exactly
its kind.

Implement -maxdepth. The start path is depth 0, its immediate entries
are depth 1, theirs depth 2, and so on. -maxdepth N prints entries at
depth N or shallower and never descends past N. Worth 40 points. The
check builds a two-level tree and asserts depth 0 prints only the start
path, and depth 1 adds its immediate children but not the grandchild.

Implement -size with the c (bytes) suffix. -size +Nc matches
entries strictly larger than N bytes, -size -Nc strictly smaller, and
-size Nc exactly N. Worth 40 points. The check creates one small and
one large file straddling a threshold and asserts each comparison keeps
the right side.

Implement -newer. With -newer <ref>, match entries whose
modification time is strictly more recent than the reference file's.
Worth 40 points. The check stamps three files with fixed, distinct
modification times — one older than the reference, one newer — and
asserts only the newer one is kept.

Implement -empty. Match regular files of zero bytes and directories
with no entries. Non-empty files and directories that contain anything
are excluded. Worth 40 points. The check builds an empty file, a
non-empty file, an empty directory and a non-empty directory, and
asserts only the two empty ones are kept.

Implement conjunction. When several predicates are given in a row, an
entry must satisfy all of them to be printed — plain find joins
predicates with an implicit AND. Worth 30 points. The check plants a
file that matches both a type and a name test, a directory that matches
only the name, and a file that matches only the type, then asserts
-type f -name "*<suffix>" keeps just the one entry that satisfies both.

Implement boolean composition. -o is OR — an entry matches if either
side does — and binds looser than the implicit AND. ! (or -not)
negates the predicate that follows. Grouping parentheses ( ... ) keep
an OR together. Worth 60 points. The check verifies a two-name OR keeps
exactly those two entries, and that ! -type d keeps every non-directory.