engineering-memory 0.4.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "0.4.0",
+  "version": "1.0.1",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/dist/src/git/git-inspector.js

@@ -4,6 +4,7 @@ import { assertManagedPath, canonicalPath } from '../utilities/files.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { NativeCommandRunner } from '../utilities/process.js';
 export const temporaryScaffoldingMarker = 'ENGINEERING-MEMORY-TEMPORARY';
+export const temporaryScaffoldingPattern = `${temporaryScaffoldingMarker}:`;
 export class GitInspector {
     runner;
     constructor(runner = new NativeCommandRunner()) {
@@ -303,7 +304,7 @@ export class GitInspector {
         return [...found.values()].sort((left, right) => left.path === right.path ? left.line - right.line : left.path.localeCompare(right.path));
     }
     async markerMatches(root, scope, origin) {
-        const result = await this.runner.run('git', ['grep', '--no-color', '-n', '-I', '-F', ...scope, '-e', temporaryScaffoldingMarker], { cwd: root });
+        const result = await this.runner.run('git', ['grep', '--no-color', '-n', '-I', '-F', ...scope, '-e', temporaryScaffoldingPattern], { cwd: root });
         if (result.exitCode !== 0)
             return [];
         return result.stdout

package/runtime/dist/src/mcp/tool-definitions.js

@@ -380,8 +380,22 @@ export function registerEngineeringMemoryTools(server, service) {
             initialProjectProfile: z.object({
                 title: z.string().min(2),
                 content: z.string().min(2),
-                screenPathPatterns: z.array(z.string().min(1)).min(1),
-                componentPathPatterns: z.array(z.string().min(1)).min(1),
+                discoveryUnits: z
+                    .array(z.object({
+                    kind: z.enum([
+                        'screen_logic',
+                        'component_mapping',
+                        'module_logic',
+                        'data_model',
+                        'api_endpoint',
+                    ]),
+                    patterns: z.array(z.string().min(1)).min(1),
+                }))
+                    .min(1)
+                    .optional()
+                    .describe('What this project calls its units and where they live. A Flutter project declares screen_logic and component_mapping; a backend declares module_logic, data_model and api_endpoint.'),
+                screenPathPatterns: z.array(z.string().min(1)).min(1).optional(),
+                componentPathPatterns: z.array(z.string().min(1)).min(1).optional(),
                 metadata: jsonObject,
                 provenance: jsonObject,
             }),

package/runtime/dist/src/runtime/bridge-service.js

@@ -1129,8 +1129,7 @@ export class BridgeService {
                 !policy ||
                 !marker ||
                 marker.projectId !== project.id ||
-                stringArray(policy.screenPathPatterns).length === 0 ||
-                stringArray(policy.componentPathPatterns).length === 0) {
+                readDiscoveryUnits(policy).length === 0) {
                 throw new Error('Project setup response is not policy-ready');
             }
             const markerPath = await this.dependencies.repositories.writeMarker(repository.repoRoot, project.id);
@@ -2369,18 +2368,11 @@ export function newMemoryResourceCandidate(entry, policy) {
         return [];
     }
     if (policy) {
-        const screen = policy.screenPathPatterns.some((pattern) => globMatches(entry.path, pattern));
-        const component = policy.componentPathPatterns.some((pattern) => globMatches(entry.path, pattern));
-        if (screen && component) {
+        const matched = policy.units.filter((unit) => unit.patterns.some((pattern) => globMatches(entry.path, pattern)));
+        if (matched.length > 1) {
             throw new Error(`Resource discovery policy is ambiguous for path: ${entry.path}`);
         }
-        if (screen) {
-            return [{ path: entry.path, kind: 'screen_logic' }];
-        }
-        if (component) {
-            return [{ path: entry.path, kind: 'component_mapping' }];
-        }
-        return [];
+        return matched[0] ? [{ path: entry.path, kind: matched[0].kind }] : [];
     }
     const extension = entry.path.toLowerCase().match(/\.[^.\/]+$/)?.[0];
     if (!extension ||
@@ -2420,12 +2412,32 @@ function readResourceDiscoveryPolicy(snapshot, activeLease) {
     if (!discovery) {
         return null;
     }
-    const screenPathPatterns = stringArray(discovery.screenPathPatterns);
-    const componentPathPatterns = stringArray(discovery.componentPathPatterns);
-    if (screenPathPatterns.length === 0 || componentPathPatterns.length === 0) {
+    const units = readDiscoveryUnits(discovery);
+    if (units.length === 0) {
         throw new Error('Pinned resource discovery policy is incomplete');
     }
-    return { screenPathPatterns, componentPathPatterns };
+    return { units };
+}
+function readDiscoveryUnits(discovery) {
+    if (!discovery)
+        return [];
+    const declared = Array.isArray(discovery.units) ? discovery.units : null;
+    if (declared) {
+        return declared.flatMap((entry) => {
+            const unit = objectValue(entry);
+            const patterns = stringArray(unit?.patterns);
+            return typeof unit?.kind === 'string' && patterns.length > 0
+                ? [{ kind: unit.kind, patterns }]
+                : [];
+        });
+    }
+    return [
+        { kind: 'screen_logic', patterns: stringArray(discovery.screenPathPatterns) },
+        {
+            kind: 'component_mapping',
+            patterns: stringArray(discovery.componentPathPatterns),
+        },
+    ].filter((unit) => unit.patterns.length > 0);
 }
 function stringArray(value) {
     if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {

package/skill/references/lifecycle.md

@@ -58,13 +58,15 @@ target inferred only from surrounding code. Carry both node ids into the discove
 checkpoint as evidence. A defect in a calculation, a response shape or a service has no
 answer in the design; do not spend the read there.
 
+Name the areas this task works in, against the coverage map the core pack carries. Where an area it touches is marked as having no rule, that is not a reason to stop — it is a finding to raise at self review, so the absence is reported by the product rather than found later by whoever inherits the code.
+
 Do not pull history for everything. Pull it for the records the task actually touches, and for anything the header shows a surprising number of corrections on. Record `task.checkpoint` with type `discovery` and update STATE, DECISIONS, DISCOVERY, and HANDOFF projections through the bridge.
 
 Send calls that do not feed each other in one batch rather than one at a time: reads of any kind, and proposals for different records. Reconcile every record the task touched in a single `task.reconcile` call with `entries`, not one call per record.
 
 Checkpoints, recorded corrections and reconciliations return before the backend has them, reporting `deliveryStatus: 'pending'` with the task version they will occupy. That is a completed call, not a pending one: the journal is already durable, delivery is already under way, and `task.verify` refuses while anything remains undelivered. Do not wait for it, poll it, or send it again. Wait only for what the next step uses — a proposal's identifiers, an approval's revision, a prepared lease, and verification itself.
 
-Temporary code written to reach or force a path — a pinned state, a fixed service response, a jump straight to the screen — is allowed and expected, carries the marker `ENGINEERING-MEMORY-TEMPORARY` with its reason, and is removed before verification. `task.verify` refuses while any marker is in the tree and names every line, and the commit gate refuses while one is staged.
+Temporary code written to reach or force a path — a pinned state, a fixed service response, a jump straight to the screen — is allowed and expected, carries the marker `ENGINEERING-MEMORY-TEMPORARY` immediately followed by a colon and its reason, and is removed before verification. `task.verify` refuses while any marker is in the tree and names every line, and the commit gate refuses while one is staged.
 
 Do not write task Markdown files directly. The bridge owns event IDs, expected task versions, atomic projections, outbox state, and synchronization.
 
@@ -106,7 +108,9 @@ Before validation, read the changed code back against the rules that govern it.
 
 Record `task.self_review` naming the resources reviewed and, for every conflict found, the file, the rule, what was wrong and what was done about it. A review that found nothing records an empty finding list, which is a claim about the work rather than a formality.
 
-`task.verify` refuses without a self review of the current diff. Editing after the review invalidates it, which is the point: the last thing that happens to the code is that someone read it against the rules. This exists because a task once shipped code that broke rules it had been given — the rules were present and correct, and nothing in the lifecycle ever asked whether the result matched them.
+An area the task worked in that the coverage map marks as having no rule is recorded as a finding too, naming the area and what was decided in its absence. That is how the product learns which rule to write next: an area nothing has needed yet can wait, and one a real task just had to improvise in cannot.
+
+This applies to a write task. A read-only task changed nothing, so there is nothing to read back against the rules and `task.self_review` is refused for it; go straight to verification. `task.verify` refuses a write task without a self review of the current diff. Editing after the review invalidates it, which is the point: the last thing that happens to the code is that someone read it against the rules. This exists because a task once shipped code that broke rules it had been given — the rules were present and correct, and nothing in the lifecycle ever asked whether the result matched them.
 
 The review is the agent's own job at the end of the work. Do not wait to be asked for it, and do not treat a passing test suite as a substitute: tests leave a receipt and readability does not, which is exactly why the unreviewed one is the one that degrades.