v0.5.5: A Skill for GitHub Copilot, an implementation that can be a whole package, and a fault outside one that says so instead of being worked around

Added

• qikly --install-skill copilot. GitHub Copilot reads none of the four
  skill directories, so every VS Code user working in Copilot rather than in
  an agent CLI had no way in except the MCP server. It reads instruction files
  out of .github/instructions/, so this writes the Skill folder there and a
  qikly.instructions.md beside it, which is the file Copilot actually opens.
  Copying the folder alone would have put files on disk that nothing ever
  reads. --install-skill auto picks it up when a project already has
  .github/instructions/ or a copilot-instructions.md, and not merely
  because it has a .github/, which almost every repository does.
• seed.implementation pointing at a directory now seeds a package. It is
  copied in under its own name and the task's code directory goes on the path
  for the test run, so from mypkg.money import to_cents, the way most real
  packages refer to themselves, resolves exactly as it does in your own tree.
  Every module in the package is visible to the coding agent, every one can be
  repaired, and a single patch may change several at once. interface.module
  becomes the real import path, mypkg.pricing. Before this a directory seed
  was flattened, which dropped the package's name and broke every
  self-referencing import inside it, so this is the shape that makes an
  implementation of more than one file work at all. A file seed and an
  unseeded run are untouched: they get no import root and an unmodified
  environment. docs/TASK_FILE_REFERENCE.md has the limits, and the full
  matrix of import shapes, including the ones that do not work, is pinned in
  tests/test_multi_module_seed.py.
• A run says when a fault is somewhere it may not write. A task owns one
  directory. Until now a defect in a helper module outside it was found by the
  tests and silently unfixable, so the run either stopped with a generic
  "exceeded 10 attempts" or, worse, changed a module it did own to work around
  a defect still sitting there. Three messages replace that: the imports it
  cannot repair are named at the start, a stall names the file rather than the
  count, and a run that goes green after a failure was traced into such a
  file says so, because that green may be a workaround. Nothing here stops,
  shortens or alters a run; a project with shared helpers is normal and the
  guard only speaks up.

Fixed

• A package-seeded implementation was shadowed by the user's own copy of it,
  so the tests never ran the code the agent was repairing. python -m pytest
  puts the working directory at the front of sys.path, ahead of anything
  PYTHONPATH adds, and the working directory is the project root where the
  original package sits. The suite imported that, every patch applied cleanly,
  and no test outcome ever changed. A pytest plugin loaded only for a
  package-seeded run now puts the task's own directory first. Nothing is
  written into your tests directory, so a seed.tests conftest.py of your
  own cannot be touched by it.
• A diff naming a file that does not exist is now matched, by unique path
  suffix, against the files that do. Small models drop a directory from a
  path they were asked to copy, and a package gives them one more to drop:
  every patch in a run came back with the task's own directory missing and all
  ten were rejected. The same repair runs when a FIX names such a path, which
  previously skipped the file in silence and left PATCH generation with no code
  in its prompt at all. Only ever reached from the state where the patch was
  about to be discarded, so a diff whose paths resolve is untouched.
• The # FILE: headers the coding agent copies into its diffs mixed \ and
  / on Windows. Forward slashes throughout now, which is the convention
  diffs use anyway.
• --install-skill copilot destroyed a file somebody else had written.
  The Copilot target writes two things, the Skill folder and the pointer file
  Copilot opens, and only the folder was covered by the promise this module
  makes about not overwriting. An existing
  .github/instructions/qikly.instructions.md was replaced by a bare
  open(path, "w"): no --force, no backup, no message. That directory is
  one people write their own instruction files into. The pointer is now moved
  to a timestamped copy first, and the install says where it went.
• A blocked pointer left the Skill folder on disk and reported that nothing
  was written. Something that is not a file sitting at the pointer's path
  raised after copytree had already run, so the state was partial and the
  message said total failure, and every re-run then said "already exists".
  It is found before anything is copied and named in the message.
• A Copilot folder with no pointer beside it reported as fine. Copilot
  reads the pointer, so that install cannot load, and "already exists, so
  nothing was changed" was true of the folder and false of the installation.
  The missing pointer is now written and said so.
• --score-suite scored nothing for an implementation of more than one
  file. It listed one directory level, so a package's modules were invisible
  to it and the report read exactly like a trivial implementation rather than
  like a failure. It now walks the tree, which is what the coding agent's own
  view of the code has always done.
• A seed.implementation resolving to .. installed outside the task's own
  directory, into the one every task shares, and the copy then recursed into
  what it had just written. Refused now, with a message naming the fix. A
  package whose name is also a standard-library module's is refused for the
  same reason: seeding a json/ would shadow the real one for everything the
  run imports.

Changed

• The Skill now sets the model rather than only warning about it (Skill
  0.3.1). Before the first paid command it sets LLM_MODEL=claude-haiku-4-5
  when ANTHROPIC_API_KEY is the key in play, and says so. That is the only
  provider whose default thinks before every answer, and a first run that
  takes twenty minutes gets blamed on qikly rather than on the key that
  happened to be set. A model chosen deliberately is left alone.
• The demo's folder is named demo/throwaway_<timestamp>/. The timestamp
  alone said when, not what, and somebody who has just watched the demo work
  is standing in something that looks exactly like a working project. The
  guard that refuses --init, --example and --demo inside one still
  recognises folders made by earlier versions.
• What --install-skill prints, in four ways. "No agent directory here
  yet" read as "your agent is not supported" to somebody sitting in one; it
  now says nothing here says which agent you use. The alternatives for Cursor
  and Copilot moved below the result, because advice about tools you do not
  use is a strange thing to read before finding out what happened. Copilot
  "reads neither" became "reads none of these", there being more than two. And
  it now says what to do when the agent does not pick it up: name it once, and
  it is usually found on its own next time, because the listing is ranked by
  how often each skill has been used and one never invoked sorts below every
  one that has.
• A suite score now says what it cannot tell you, under the number: it
  reports how much of the code that is there your tests would notice being
  changed, and nothing about a rule nobody implemented, because there is
  nothing there to break. A seventeen-test suite caught 8 of 8 planted faults
  in a real session while a suite written from the specification found four
  genuine bugs in the same file. The Skill says the same to an agent before it
  hands somebody a percentage.

---

• The README test badge floor moves to 1,700+ tests. It is a floor rather
  than a count, so it is deliberately behind what the suite actually runs.